{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def rho_theta(theta):\n",
    "    return np.exp(np.sin(theta))*np.sin(3*theta)**2+np.exp(np.cos(theta))*np.cos(3*theta)**2\n",
    "    \n",
    "def rho_xy(x,y):\n",
    "    return rho_theta(np.angle(x+y*1j))\n",
    "\n",
    "def x_theta(theta):\n",
    "    return rho_theta(theta)*np.cos(theta)\n",
    "\n",
    "def y_theta(theta):\n",
    "    return rho_theta(theta)*np.sin(theta)\n",
    "\n",
    "def R(x,y):\n",
    "    return np.sqrt(x**2+y**2)\n",
    "\n",
    "def U(x,y):\n",
    "    return np.cos(k*x*y+k*y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=5\n",
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True\n",
    "#equation_component_combination = [1.0,2.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = loadmat('data.mat')['uxy_list'][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observation_data = []\n",
    "\n",
    "theta_list = np.linspace(0,np.pi*2,800)\n",
    "for theta in theta_list:\n",
    "    x = x_theta(theta)\n",
    "    y = y_theta(theta)\n",
    "    comb = [1,0,0]\n",
    "    v = U(x,y)\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.14879 | domain_loss:  557.84418 | bdc_loss:    0.57611\n",
      "epoch:  200.00000 | total_loss:    0.89408 | domain_loss:   38.97140 | bdc_loss:    0.50946\n",
      "epoch:  400.00000 | total_loss:    0.53699 | domain_loss:    8.76434 | bdc_loss:    0.45388\n",
      "epoch:  600.00000 | total_loss:    0.43354 | domain_loss:    3.48987 | bdc_loss:    0.40267\n",
      "epoch:  800.00000 | total_loss:    0.36898 | domain_loss:    1.89696 | bdc_loss:    0.35354\n",
      "epoch: 1000.00000 | total_loss:    0.31643 | domain_loss:    1.20625 | bdc_loss:    0.30744\n",
      "epoch: 1200.00000 | total_loss:    0.27329 | domain_loss:    0.81147 | bdc_loss:    0.26786\n",
      "epoch: 1400.00000 | total_loss:    0.24182 | domain_loss:    0.55140 | bdc_loss:    0.23870\n",
      "epoch: 1600.00000 | total_loss:    0.22269 | domain_loss:    0.38155 | bdc_loss:    0.22109\n",
      "epoch: 1800.00000 | total_loss:    0.21296 | domain_loss:    0.27824 | bdc_loss:    0.21230\n",
      "epoch: 2000.00000 | total_loss:    0.20821 | domain_loss:    0.21893 | bdc_loss:    0.20811\n",
      "epoch: 2200.00000 | total_loss:    0.20533 | domain_loss:    0.18766 | bdc_loss:    0.20551\n",
      "epoch: 2400.00000 | total_loss:    0.20292 | domain_loss:    0.17536 | bdc_loss:    0.20320\n",
      "epoch: 2600.00000 | total_loss:    0.20050 | domain_loss:    0.17696 | bdc_loss:    0.20074\n",
      "epoch: 2800.00000 | total_loss:    0.19793 | domain_loss:    0.18966 | bdc_loss:    0.19801\n",
      "epoch: 3000.00000 | total_loss:    0.19509 | domain_loss:    0.21219 | bdc_loss:    0.19492\n",
      "epoch: 3200.00000 | total_loss:    0.19193 | domain_loss:    0.24442 | bdc_loss:    0.19140\n",
      "epoch: 3400.00000 | total_loss:    0.18833 | domain_loss:    0.28720 | bdc_loss:    0.18733\n",
      "epoch: 3600.00000 | total_loss:    0.18421 | domain_loss:    0.34213 | bdc_loss:    0.18261\n",
      "epoch: 3800.00000 | total_loss:    0.17943 | domain_loss:    0.41150 | bdc_loss:    0.17709\n",
      "epoch: 4000.00000 | total_loss:    0.17385 | domain_loss:    0.49798 | bdc_loss:    0.17058\n",
      "epoch: 4200.00000 | total_loss:    0.16732 | domain_loss:    0.60419 | bdc_loss:    0.16291\n",
      "epoch: 4400.00000 | total_loss:    0.15968 | domain_loss:    0.73164 | bdc_loss:    0.15390\n",
      "epoch: 4600.00000 | total_loss:    0.15082 | domain_loss:    0.87918 | bdc_loss:    0.14346\n",
      "epoch: 4800.00000 | total_loss:    0.14069 | domain_loss:    1.04082 | bdc_loss:    0.13160\n",
      "epoch: 5000.00000 | total_loss:    0.12942 | domain_loss:    1.20427 | bdc_loss:    0.11857\n",
      "epoch: 5200.00000 | total_loss:    0.11731 | domain_loss:    1.35145 | bdc_loss:    0.10484\n",
      "epoch: 5400.00000 | total_loss:    0.10489 | domain_loss:    1.46284 | bdc_loss:    0.09117\n",
      "epoch: 5600.00000 | total_loss:    0.09289 | domain_loss:    1.52486 | bdc_loss:    0.07843\n",
      "epoch: 5800.00000 | total_loss:    0.08215 | domain_loss:    1.53694 | bdc_loss:    0.06745\n",
      "epoch: 6000.00000 | total_loss:    0.07327 | domain_loss:    1.51220 | bdc_loss:    0.05874\n",
      "epoch: 6200.00000 | total_loss:    0.06649 | domain_loss:    1.47006 | bdc_loss:    0.05232\n",
      "epoch: 6400.00000 | total_loss:    0.06159 | domain_loss:    1.42632 | bdc_loss:    0.04781\n",
      "epoch: 6600.00000 | total_loss:    0.05808 | domain_loss:    1.38820 | bdc_loss:    0.04465\n",
      "epoch: 6800.00000 | total_loss:    0.05544 | domain_loss:    1.35563 | bdc_loss:    0.04231\n",
      "epoch: 7000.00000 | total_loss:    0.05325 | domain_loss:    1.32474 | bdc_loss:    0.04040\n",
      "epoch: 7200.00000 | total_loss:    0.05118 | domain_loss:    1.29103 | bdc_loss:    0.03865\n",
      "epoch: 7400.00000 | total_loss:    0.04900 | domain_loss:    1.25189 | bdc_loss:    0.03685\n",
      "epoch: 7600.00000 | total_loss:    0.04665 | domain_loss:    1.20965 | bdc_loss:    0.03490\n",
      "epoch: 7800.00000 | total_loss:    0.04390 | domain_loss:    1.14067 | bdc_loss:    0.03282\n",
      "epoch: 8000.00000 | total_loss:    0.04035 | domain_loss:    1.00608 | bdc_loss:    0.03059\n",
      "epoch: 8200.00000 | total_loss:    0.03585 | domain_loss:    0.82172 | bdc_loss:    0.02791\n",
      "epoch: 8400.00000 | total_loss:    0.03111 | domain_loss:    0.64024 | bdc_loss:    0.02496\n",
      "epoch: 8600.00000 | total_loss:    0.02680 | domain_loss:    0.50212 | bdc_loss:    0.02200\n",
      "epoch: 8800.00000 | total_loss:    0.02303 | domain_loss:    0.40236 | bdc_loss:    0.01920\n",
      "epoch: 9000.00000 | total_loss:    0.01979 | domain_loss:    0.32747 | bdc_loss:    0.01669\n",
      "epoch: 9200.00000 | total_loss:    0.01704 | domain_loss:    0.26970 | bdc_loss:    0.01449\n",
      "epoch: 9400.00000 | total_loss:    0.01471 | domain_loss:    0.22424 | bdc_loss:    0.01259\n",
      "epoch: 9600.00000 | total_loss:    0.01273 | domain_loss:    0.18782 | bdc_loss:    0.01096\n",
      "epoch: 9800.00000 | total_loss:    0.01103 | domain_loss:    0.15810 | bdc_loss:    0.00955\n",
      "epoch: 10000.00000 | total_loss:    0.00955 | domain_loss:    0.13329 | bdc_loss:    0.00830\n",
      "epoch: 10200.00000 | total_loss:    0.00824 | domain_loss:    0.11220 | bdc_loss:    0.00719\n",
      "epoch: 10400.00000 | total_loss:    0.00706 | domain_loss:    0.09371 | bdc_loss:    0.00618\n",
      "epoch: 10600.00000 | total_loss:    0.00600 | domain_loss:    0.07751 | bdc_loss:    0.00528\n",
      "epoch: 10800.00000 | total_loss:    0.00507 | domain_loss:    0.06368 | bdc_loss:    0.00447\n",
      "epoch: 11000.00000 | total_loss:    0.00426 | domain_loss:    0.05280 | bdc_loss:    0.00377\n",
      "epoch: 11200.00000 | total_loss:    0.00356 | domain_loss:    0.04209 | bdc_loss:    0.00317\n",
      "epoch: 11400.00000 | total_loss:    0.00301 | domain_loss:    0.03685 | bdc_loss:    0.00267\n",
      "epoch: 11600.00000 | total_loss:    0.00249 | domain_loss:    0.02854 | bdc_loss:    0.00222\n",
      "epoch: 11800.00000 | total_loss:    0.00195 | domain_loss:    0.02042 | bdc_loss:    0.00177\n",
      "epoch: 12000.00000 | total_loss:    0.00151 | domain_loss:    0.01544 | bdc_loss:    0.00137\n",
      "epoch: 12200.00000 | total_loss:    0.00118 | domain_loss:    0.01341 | bdc_loss:    0.00106\n",
      "epoch: 12400.00000 | total_loss:    0.00090 | domain_loss:    0.00921 | bdc_loss:    0.00081\n",
      "epoch: 12600.00000 | total_loss:    0.00067 | domain_loss:    0.00663 | bdc_loss:    0.00061\n",
      "epoch: 12800.00000 | total_loss:    0.00052 | domain_loss:    0.00771 | bdc_loss:    0.00045\n",
      "epoch: 13000.00000 | total_loss:    0.00036 | domain_loss:    0.00351 | bdc_loss:    0.00033\n",
      "epoch: 13200.00000 | total_loss:    0.00025 | domain_loss:    0.00241 | bdc_loss:    0.00023\n",
      "epoch: 13400.00000 | total_loss:    0.00018 | domain_loss:    0.00273 | bdc_loss:    0.00015\n",
      "epoch: 13600.00000 | total_loss:    0.00011 | domain_loss:    0.00102 | bdc_loss:    0.00010\n",
      "epoch: 13800.00000 | total_loss:    0.00007 | domain_loss:    0.00076 | bdc_loss:    0.00006\n",
      "epoch: 14000.00000 | total_loss:    0.00004 | domain_loss:    0.00035 | bdc_loss:    0.00004\n",
      "epoch: 14200.00000 | total_loss:    0.00002 | domain_loss:    0.00020 | bdc_loss:    0.00002\n",
      "epoch: 14400.00000 | total_loss:    0.00001 | domain_loss:    0.00025 | bdc_loss:    0.00001\n",
      "epoch: 14600.00000 | total_loss:    0.00001 | domain_loss:    0.00005 | bdc_loss:    0.00001\n",
      "epoch: 14800.00000 | total_loss:    0.00000 | domain_loss:    0.00010 | bdc_loss:    0.00000\n",
      "epoch: 15000.00000 | total_loss:    0.00000 | domain_loss:    0.00001 | bdc_loss:    0.00000\n",
      "epoch: 15200.00000 | total_loss:    0.00000 | domain_loss:    0.00001 | bdc_loss:    0.00000\n",
      "epoch: 15400.00000 | total_loss:    0.00003 | domain_loss:    0.00298 | bdc_loss:    0.00000\n",
      "epoch: 15600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 15800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16200.00000 | total_loss:    0.00001 | domain_loss:    0.00073 | bdc_loss:    0.00000\n",
      "epoch: 16400.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 16800.00000 | total_loss:    0.00000 | domain_loss:    0.00011 | bdc_loss:    0.00000\n",
      "epoch: 17000.00000 | total_loss:    0.00000 | domain_loss:    0.00004 | bdc_loss:    0.00000\n",
      "epoch: 17200.00000 | total_loss:    0.00000 | domain_loss:    0.00001 | bdc_loss:    0.00000\n",
      "epoch: 17400.00000 | total_loss:    0.00000 | domain_loss:    0.00031 | bdc_loss:    0.00000\n",
      "epoch: 17600.00000 | total_loss:    0.00001 | domain_loss:    0.00115 | bdc_loss:    0.00000\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18000.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18200.00000 | total_loss:    0.00000 | domain_loss:    0.00002 | bdc_loss:    0.00000\n",
      "epoch: 18400.00000 | total_loss:    0.00000 | domain_loss:    0.00004 | bdc_loss:    0.00000\n",
      "epoch: 18600.00000 | total_loss:    0.00000 | domain_loss:    0.00000 | bdc_loss:    0.00000\n",
      "epoch: 18800.00000 | total_loss:    0.00000 | domain_loss:    0.00001 | bdc_loss:    0.00000\n",
      "epoch: 19000.00000 | total_loss:    0.00000 | domain_loss:    0.00001 | bdc_loss:    0.00000\n",
      "epoch: 19200.00000 | total_loss:    0.00000 | domain_loss:    0.00001 | bdc_loss:    0.00000\n",
      "epoch: 19400.00000 | total_loss:    0.00000 | domain_loss:    0.00008 | bdc_loss:    0.00000\n",
      "epoch: 19600.00000 | total_loss:    0.00000 | domain_loss:    0.00001 | bdc_loss:    0.00000\n",
      "epoch: 19800.00000 | total_loss:    0.00001 | domain_loss:    0.00055 | bdc_loss:    0.00000\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0002), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'error')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA14AAADgCAYAAAAT8LdqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABO5klEQVR4nO29fbwdZXnv/f3lZe8gkASIYExQUIMYecQqBY6np2IRDdQ22toW9AhaPTxYaHse26eg1tZWsWhPn6McFZ5ILdD2SKmtNbYRi1RLq6ZCLaJEkAgKERQTTMJrkp19nT/WrGT2yqxZs2bmnrd1fT+f9dlrzcx9zzWzZv/Wdd0v1y0zw3Ecx3Ecx3EcxwnHvLoNcBzHcRzHcRzH6ToeeDmO4ziO4ziO4wTGAy/HcRzHcRzHcZzAeODlOI7jOI7jOI4TGA+8HMdxHMdxHMdxAuOBl+M4juM4juM4TmA88HIAkPRdSS+P3r9D0lU567lD0mll2uY4TveR9EVJb6nbDsdxHMcJxYK6DXCah5m9L8txkq4GtpjZ78bKPj+UXY7jNANJ3wXeYmafz1n+3cBzzOy/lmmX4ziO4zQZ7/HqIJI8oHYcpxZcfxzHCcWgvqhHZl923OMdp2z84WsR0XDAt0vaJOnHkv5M0iJJp0naIuliST8A/kzSPEmXSPqOpG2Srpd0eKyuN0j6XrTvnQPnebekv4h9/ilJX5a0XdL9kt4o6Xzg9cDvSHpU0mdiNvaHLE5L+qCkB6LXByVNR/v6Nv+WpIckPSjpTRXcRsdxCiDpz4FnAJ+J/vd/R5JJerOk+4B/6v9/D5T7rqSXS1oDvAP4laj812OHPVPSlyQ9IukfJS2r7socx6kLSU+X9DeSfiTpXkm/EW1/t6RPSvoLSTuBN0bDki+V9CXgceBZkl4i6RZJO6K/L4nVfcDxtVyk4+CBVxt5PfBK4NnAcUB/mN/TgMOBZwLnA78BvBp4KfB04MfARwAkrQauAN4Q7TsCWJl0MknPAD4L/C/gqcALgdvMbB3wl8AHzOwQM/u5hOLvBE6NypwInByzt2/zEmAF8GbgI5IOy34rHMepGjN7A3Af8HNmdghwfbTrpcDz6OlTWvkbgPcBfxVpx4mx3a8D3gQcCUwBv12y+Y7jNIyoB+ozwNfp+QOnA/9dUl9L1gKfBJbS8zug57+cDxwKPAL8A3A5PX/m/wP+QdIRsdPEj/9ewMtxnFQ88GofHzaz+83sYeBS4Jxo+yzw+2a2y8yeAP5v4J1mtsXMdgHvBl4bddO/Fvh7M7s52veuqHwSrwc+b2afMLM9ZrbNzG7LaOvrgT80s4fM7EfAH9ATvz57ov17zGwD8Cjw3Ix1O47TLN5tZo9F+pOXPzOzb0d1XE+v0cZxnG7zk8BTzewPzWy3md0DfAw4O9r/FTP7OzObjenL1WZ2h5nNAK8A7jazPzezGTP7BHAnEG8Q3ne8me2p6sIcZxAfi98+7o+9/x69HiuAH5nZk7F9zwQ+JSkeUO0FjorK7KvHzB6TtG3I+Y4GvpPT1qczt2Upbi/Atkg0+zwOHJLzXI7j1Mv9ow8ZyQ9i710PHGcyeCbwdEnbY9vmA/9Cz29I0pb4tkFfg+jziiHHO05teI9X+zg69v4ZwAPRexs47n7gTDNbGnstMrPvAw/G65H0FHrd80ncT29YYxKD5xzkAXqCmmSv4zjtJel/P77tMeAp/Q+S5tMbqpxW3nGcyeR+4N4Bf+VQMzsr2j9KbwZ9Dej5G98fcrzj1IYHXu3jQkkro0QZ7wD+ashxVwKXSnomgKSnSlob7fsk8KooacYU8IcMfxb+Eni5pF+WtEDSEZJeGO37IemTVD8B/G507mXA7wF/kXK84zjtYNT//reBRZJ+VtJCenM7pwfKH+PZxRzHAb4K7IwShB0kab6kEyT9ZMbyG4DjJL0u8lN+BVgN/H0wix0nJ/6j1z7+N/CPwD3R671DjvsQsB74R0mPABuBUwDM7A7gwqiuB+kl3tiSVImZ3QecBfwW8DBwG71EGQB/CqyOsh3+XULx9wK3ArcD3wC+lmKv4zjt4Y/oNapspzdndA5mtgP4NeAqeq3OjzFXY/46+rtN0tfCmuo4TpMxs7305mO9ELgX2EpPO5ZkLL8NeBU9P2Ub8DvAq8xsawh7HacIMvPe17aggouWOo7jOI7jOI5TD97j5TiO4ziO4ziOE5hggZekj0cL435zyH5JulzSZkm3S3pRKFscx2k3rieO45SF64njOHURssframBNyv4zgVXR63x6C/o6KZjZMT7M0JlQrsb1xHGccrga1xPHcWogWOBlZjfTS8YwjLXAtdZjI7BU0vJQ9jiO015cTxzHKQvXE8dx6qLOOV4rmLug3RbmLnbnOI6TFdcTx3HKwvXEcZwgLKjx3ErYlphiUdL59Lr7mX7KvBcfdexTkg5znNZz3x2PbjWzp44+0hnA9cRxBnA9yU0uPZm3YOrFi5YeOdaJZucPnCT6rL1zt88b+DysDps//Lg0Bs+XdO5BW9POl8WO/jn7fwevcXb+/npsPjC/9xVo/v6vwvZGX9VeDa1vNl5H3Lb5CV9pVF/8fqTdm0Gy3o9BW+P2au+Bx6d9x6O+u6TvbVye/OEW15KSqDPw2gIcHfu8kt7q4wdgZuuAdQDPPOFQe8ff+DxXp5tccPzN36vbhpbieuI4A7ie5CaXnhz81KPt+Ne8bawT7V6c7bipndnr2J1p9auB+nekn3uYnWnn2rNkdui+hTv2D7jqnzt+jf3z9evv1zW7eIbpxbv2Hbdr5zTzdi6YU+dgfYN19eubXTwzx6Z+PcPsy0rSPRm8F4O2xu1NrDPlO8773WVlaid87WNvcy0piTqHGq4Hzo2yB50K7DCzB2u0x3Gc9uJ64jhOWbieZCTN6Y8HL1nIGiDs2jk9529e4oHWsKCrLOJ1hqh/GEWDLqd8gvV4SfoEcBqwTNIW4PeBhQBmdiWwATgL2Aw8DrwplC2O47Qb1xPHccoilJ6UMaSrayzcMS+152sUUzt6vTv9eubtXMDs4pl9Qddgb9cgdQQefZsHKXovhp0rJGm9cE4+ggVeZnbOiP0GXBjq/I7jdAfXE8dxysL1ZC6jnPeiwctgwFFVj0+a3fFAbnB7SPIMYayr18qDrjDUOdTQcRzHcRzHKZHQvSBlni9P2cFgaRKZ2hH2e/agKxweeDmO4ziO40wYoZ33OFl7kkb1UsUZNwAbda1JNua9P1UHv0578GYDx3Ecx3GcFpJnGFpdQUGZw/jKSIYRHwJZZcKLpuO9XWFpXeB10Lw9dZvgOI3hZ162yB5+OHmy7tdv3/M5M1tTsUmtwvXEcXqkaQm4nnSBtvTCTGomvt2LmxH0lGHH6S9bZNvcN0mkdYEXwOrp77Nply8i7zgPPzzLjZ9NXtPwyBUPLKvYnFbieuI46VoCriehyLLOUh4nOJ5Zr4qAa1gmv7IZlahj3GsN2dOVdk+aHgT3n8m8Adi2h2e56bPJi4kvW/H9idaS1vatrp7+ft0mOI7TEVxPHMfpGlXO4cpzvqYHH2XYV/Q7qLv3b/fi+m3oGq0NvMCdJcdxysP1xHGcouSac5WzV6GpDnHZAdVgff1eqjy9VVltC3kNTQ84nbC0OvACd5YcxykP1xPHcZpEE+b85GFUT0/R4KPMDIRV0XT7nGpo5RyvQXyOxnjc+cTyoPUff9CDQet3nJC4noyH64njFCfLXK82UtXcr3EYZVPQ9bEyLFbd1mC7TCStAT4EzAeuMrPLBvYr2n8W8DjwRjP7WlpZSYcDfwUcA3wX+GUz+7GkM4DLgClgN/D/mtk/RWVeDFwNHARsAH4zWmA9N50IvMCdpTihHaGyzu8OVb1I+jjwKuAhMzshYf/rgYujj48CbzWzr1doYm24nuzH9cTJguuJM4zBQMd7fpw0JM0HPgKcAWwBbpG03sw2xQ47E1gVvU4BrgBOGVH2EuAmM7tM0iXR54uBrcDPmdkDkk4APgf0HYArgPOBjfQCrzXAZ4tcX2cCL5gcZ6luR6gs0q7DnahKuBr4MHDtkP33Ai+NWoTOBNbRE7iJYBL0pCtaAq4nDeBqXE8KMU6vV9t6x/rBVt7er7J7qYbV16SgsG3fcYmcDGw2s3sAJF0HrAXigdda4Nqo92mjpKWSltPrzRpWdi1wWlT+GuCLwMVm9h+xeu8AFkmaBg4HFpvZV6K6rgVejQdec+mis9Ql5ygrw67ZHajyMLObJR2Tsv/LsY8bgZXBjXKC43rSw7WkXFxP9lPWcLEuDjlrUmDjNJYVwP2xz1s4sJEm6ZgVI8oeZWYPApjZg5KS8t3/IvAfZrZL0oqo/OA5CtG5wKsrTKJzlIX4fXHHaSTLJN0a+7zOzNblrOvNFGzlaSNdachxPTmQwXviejIS15OKSQvgujonLI2ye6l8CGQ4njRx156pYbtHaYkSygzOqxp2TJayiUh6PvB+4BVj2DE2nQy82uwsuYOUHQ/C4Embx527Dxq2e6uZnVT0HJJeRs9R+qmidTnV4VoyHpOuJyO0BFxPxsKTJIQhVLIOD7oqZZSWbAGOjn1eCTyQ8ZiplLI/lLQ86u1aDjzUP0jSSuBTwLlm9p3YOVYOqSs3rU8n3wXufGL5vpeTD7+HYZD0AuAqYK2ZbavbnjpoW4p5/z8ojutJGFxP0pm0HqwyKBowVb3ItJOJW4BVko6VNAWcDawfOGY9cK56nArsiIYRppVdD5wXvT8P+DSApKXAPwBvN7Mv9U8Q1feIpFOjLIrn9ssUoZM9Xm3Bf9TDMOkt12Uh6RnA3wJvMLNv122Pk47rSRj699W1pBiTqCehe70mcbgheKDUdcxsRtJF9LILzgc+bmZ3SLog2n8lvQyDZwGb6aWTf1Na2ajqy4DrJb0ZuA/4pWj7RcBzgHdJele07RVm9hDwVvank/8sJQyR7mzg1eThhu4gVYc7TcOR9Al6GX6WSdoC/D6wEPYJ2+8BRwAf7TX2MFPGUCOnXFxPqsG1JB3XE8dxysLMNtALruLbroy9N+DCrGWj7duA0xO2vxd475C6bgUOWB6jCJ0NvJqIO0j14U7TgZjZOSP2vwV4S0XmNJomNuS4ntSD96gn43qSjM/1ctqOP7/l4oFXRbiT1Aw8AHPajmtJc3A9ccoi75DBSR1u6ITFg61wdDq5RhMmxfsE7Wbi34vTRvyZbSb+vThpeGDktIWpnR50habTgVfd+I9x8/HvyMlK3Q05/qw2G2/McYaRxZFNOsYdYKdqdi/2hoLQ+FBDZ+K584nlPlTIaTTu0LcH1xMnzjjBU3zYoAddk0lTvvd48JXHpidnF3LnrqcP2XtvLpu6ggdegXBHqV201Vl6YnZhStKH7wzZ7rQJ15L20UY9SdcScD0ZnzwOa1Mcb8fp4z1g5dL5oYZ1DA9yR6md+PfmNA1/JtuLf3eTjQdQjuMkETTwkrRG0l2SNku6JGH/EkmfkfR1SXdIelNIe6rAf2zbjc/TaC6TqCdOu3EtaSahtaTqoKtLQd4kJ3eY1OueNIIFXpLmAx8BzgRWA+dIWj1w2IXAJjM7kd7Ci38iaSqUTaHxH9nu4N9ls2iKnlTZg+7PYDfw77FZhNYSd57zE793ZdzHSQ7i2k6GxhFJujzaf7ukF40qK+lwSTdKujv6e1i0/QhJX5D0qKQPD5xnStI6Sd+WdKekXyx6bSF7vE4GNpvZPWa2G7gOWDtwjAGHqreM/SHAw8BMQJuC4T+u3cO/00bheuK0Fu9JbxTBtGTe3rJNrZ9+8BIygBlWf5FzDgZxTQ/Amm5flWRsHDkTWBW9zgeuyFD2EuAmM1sF3BR9BngSeBfw2wnmvBN4yMyOi+r756LXFzK5xgrg/tjnLcApA8d8GFgPPAAcCvyKmc0OViTpfHo3lqOe3rx8IG3/Qb3n0WWl1POsQ7aWUk+TaOMk+axIWgN8CJgPXGVmlw3sPwz4OPBsesL0q2b2zcoN7eF60gJcS9JxPWmEnpSmJTBXT6YOOax0Y+tiWCBUdqKFUQFHf/845x1WZ3y7J4xoNPsaRwAk9RtHNsWOWQtca2YGbJS0VNJy4JiUsmvp9WADXAN8EbjYzB4D/lXScxJs+VXgeIBIAwr/OIX0OpSwzQY+vxK4DfgZemJ8o6R/MbM5/zZmtg5YB3D8CxYN1uFkpCynaNz62+5EddFZirUKnUHP8bhF0noziwvbO4DbzOw1ko6Pjj+9emuBCdGTNgVdIfUkre6260kXaZmelKYlMFdPDn7q0bXpSVlBUYhAKM95ko4fdc5xU/dDep3j2pj3nqQFihMaIGZpHEk6ZsWIskeZ2YMAZvagpCPTjJC0NHr7Hkmn0UvtepGZ/TDrhSQRMvDaAhwd+7ySXutRnDcBl0UR62ZJ99KLLL8a0K5SaaqjFDrIGodBW9xxagRZWpRWA38EYGZ3SjpG0lFFRScnE6EnTcX1pDy62JBDu/QkmJbMzi/TzPEp6qiXHbgUqT/rOcuqswzy9KhlCXTbGHztsoV8+8mnDdu9TNKtsc/rogaMPlkaR4Ydk6VsVhbQ04cvmdnbJL0N+B/AG3LWt6/SUNwCrJJ0LPB94GzgdQPH3EevxetfJB0FPBe4p2xDVk9/f8T6JN2hSQ7SMOI2tsVpaqmzlCZuWVqUvg78Ar0u+JOBZ9IToToCr8boSSia1ojTBi0B15MK6YqeBNWS3Yvrna+T11HPa3Md19qG+VCjgrC8C2t3hK1mdlLK/iyNI8OOmUop+0NJy6PeruXAQyPs3AY8Dnwq+vzXwJtHlBlJsMDLzGYkXQR8jt6Y74+b2R2SLoj2Xwm8B7ha0jfoRakXm1k7fjlpjqPUFgcpiba3XtfNk7ML057DNHHL0ip0GfAhSbcB3wD+g5qSVUyCnjSFruiJa8l4jNAS6IieVKElTQ++2hC4dImyMjR2LPhKI0vjyHrgoqh3/RRgRxRQ/Sil7HrgPHpadB7w6TQjzMwkfYbevLB/otcYsymtTBaCziw3sw3AhoFtV8bePwC8IqQNXaXNzlEa/etqotPU0lbqYYxsUYrmM7wJeqlbgXujVy10WU/qbsTpop40WUvA9YQa9aQKLWlC8OU4RanjOcrYOLIBOAvYTK9X6k1pZaOqLwOul/Rmer3av9Q/p6TvAouBKUmvBl4RzVG9GPhzSR8EftQ/TxGal9KrJdTlKHXRQUqiqU5Th5ylkS1K0cTSx6OUy28Bbk6aXD5pdGno8iToSZN7wVxPuq0ndQdfTreouterzmc3Q+OI0VtvL1PZaPs2hiT0MbNjhmz/HvDTWe3OggdeLWISnKRBmhqAtZ2MLUrPA66VtJde93rhsc3OgdTRiDOJWgKuJ6FwPRmOB19OmVQRfPnzGhYPvHJQtaM0qU5SnCY5TF1ppc7QovQVeosTOh3C9cT1JASuJ8Px4Mspk5DBlz+n4ZlXtwHOcO55dJk7SQM05Z7UPSfHccalKf87TcLvh1MF7sw6ZRPqmdq9eP/LCYMHXmNSlcPtDkE6fn+cLuB6Uj9NCEi9Iae7eNDltBUPwsLgQw0bSN1OQFu459FltQ4V6soQIae7uJZkp249cbqHB11OSJqcYn7X7ALufcx/f5LwHq8G0YSW17bh98xpK6F7Ofz/YnzqvGfe69UtPOhyHCeJ1vV4LdJsbecO+cPoTlIxJrW1etfsAn92ClCnnoTEn4n8NCnxRpW4lpSHB12O4wzDe7wagP/YlUMd99FbqZ2m4XpSDq4nTh486HK6xu4ldVvQLTzwqhl3ksrFhx46bSCUg+3Pfrn4/XTGYd7eui1wJo2Qgf7uJR50haCVgdfxU09Ufs4QjpL/qIejynvrrdROE3A9CYPfV8dxJo26Ay5JayTdJWmzpEsS9kvS5dH+2yW9aFRZSYdLulHS3dHfw6LtR0j6gqRHJX04dvxTJP2DpDsl3SHpsjKurZWBVxfwH/Pw+D12JgV/1sPiDTmO4zjVIGk+8BHgTGA1cI6k1QOHnUlvQfZVwPnAFRnKXgLcZGargJuizwBPAu8CfjvBnP9hZscDPwH8Z0lnFr2+1iXXcMpnyyPFmzZWHrqjBEucKpG0BvgQMB+4yswOaM2RdBrwQWAhsNXMXlqhiZVw/NQT3Ln7oMrOV7Zj3bSgq6t6MqkJfLLiegKz8+u2wJlEQqSVn4okuKaer5OBzWZ2D4Ck64C1wKbYMWuBa83MgI2SlkpaDhyTUnYtcFpU/hrgi8DFZvYY8K+SnhM3wsweB74Qvd8t6WvAyqIX54FXBrrmKJXhGI2qsymOU1XOUtvW9Iq1Cp0BbAFukbTezDbFjlkKfBRYY2b3STqyFmOdodStJeB64riexNm92BNsON1hKoz0LpN0a+zzOjNbF/u8Arg/9nkLcMpAHUnHrBhR9igzexDAzB4cR4Mi/fo5eo1LhfDAq2LqcpRCOEfjnK9Ox8mdpUSytCi9DvhbM7sPwMweqtxKp3FUrSVJ5+y6nrStIQfXkzl48OVUTdMWU969dz5bHh36W7HVzE5KKa6EbZbxmCxlx0LSAuATwOV9jSuCB14VUmXQVYdzlEbcnjqcJg++DiBLi9JxwEJJXwQOBT5kZtdWY54zCteT+gIw15MDcD0ZwIMvx8nNFuDo2OeVwAMZj5lKKftDScuj3q7lQNbGn3XA3Wb2wYzHp+KBV0VU5SQ1zUFKoi6nKbSzVEcr9Z6989O+87Tu/CytQguAFwOnAwcBX5G00cy+XcTmSaasYcuuJz3qDMC6FnyN0BJwPRkbD76cKmlar1cBbgFWSToW+D5wNr0e8zjrgYui3vVTgB1RQPWjlLLrgfOAy6K/nx5liKT3AkuAtxS+qojWBl5VTYhvU4appjtJg9ThNHXNWRpBWnd+1halrdHE08ck3QycCHTWUWoDVQRdbdUSaM58sKI0cLih60kOPPhy2kpdz62ZzUi6CPgcvWQ9HzezOyRdEO2/EtgAnAVsBh4H3pRWNqr6MuB6SW8G7gN+qX9OSd8FFgNTkl4NvALYCbwTuBP4miSAD5vZVUWur7WBV5sI7Si1zUkapO5hQxNKlhalTwMfjsY3T9FrVfqflVrpVI7rSXYmrCEnDdeTFDz4qofp7bPsWjpZqyYV7fVqynNqZhvoBVfxbVfG3htwYday0fZt9Hrck8ocM8SUpN78QnjgFZiQQVfbHaRBqnKY3FnK1qJkZt+SdANwOzBLL0X0N+uzut2U0XvuepKdLY8s8eCrIlxPnKYwvX028fOkBGBdCLq6jgdeLaRrDtIgVThMoZylBg4PGsqoFqXo8x8Df1ylXXVQ9VpeTaLLeuKNOdXhejIcd2jDMhhspR0zKQGY01z8CUyhaAt1iNbpLjtJcSblOh0nK64n+WnrdbZpjrFzIFM7PegKxfT22X2vcct1lY4k1ug83uPVItrqPOQldGu1t1I7k8wk6knIni/XEyeOB1zFCRUkee9XMmXORZyZnc/WRw4up7KOEfSpk7RG0l2SNku6ZMgxp0m6TdIdkv45pD1VUnbr9KQ5SXFCXntdC1o74+N6Uh6TqidbHlkysdfu7Ce0lnjQlZ+8PVl5z+U4VRMs8JI0H/gIcCawGjhH0uqBY5YCHwV+3syeTyy1o7MfdxTadQ98eFD5tF1PmvRMtOl/KRSh7oE35DSfkFoyb68HXUWoIxCqKsgLjQ8zbA8hhxqeDGw2s3sAokXO1gKbYse8DvhbM7sPwMyyriIdnCKOUpk/vu4k7SfU0MM2DxGa2TuP7Tsmoju/1XpShLL0xLVkLqGGHpatJ1Ul7HEt6b6WNJUmBD4+/NCpipBP2Arg/tjnLdG2OMcBh0n6oqR/l3RuQHtahztKyfh9mUgmUk886AqL35eJZCK1pIk0sbepyqGOZVFmb5f3nIUnZOCVtOiYDXxeALwY+FnglcC7JB13QEXS+ZJulXTrtm3N/mdwR6kayr4/PkSo8UyknpSBa0k6Ie6P60mjKU1LYK6ezDz5WLmWdpS2BDZtsDEEuxcf+KqaUfMw1ePyaP/tkl40qqykwyXdKOnu6O9hsX1vj46/S9IrY9vPkfSN6Bw3SCos7iEDry3A0bHPK4EHEo65wcweM7OtwM3AiYMVmdk6MzvJzE464ojudwPX7Sht33Fw6qsp1H2fnEppjJ5s2jXYOB6GMpz3JvyPtEFPmnCfnMooTUtgrp4sWNSM57nJtC2YaYO9XZtXmGUeZrRvVfQ6H7giQ9lLgJvMbBVwU/SZaP/ZwPOBNcBHJc2XtAD4EPAyM3sBvcXfLyp6fSGjmFuAVZKOlTRF76LWDxzzaeC/SFog6SnAKcC3AtoUlLY5SnkdoSY7UEUos5W6SckUOkJr9aSuZ6HqYKLteuK96BNDMC2ZnV+6rZ2iDUFMEm21u8Xsm4dpZruB/jzMOGuBa63HRmCppOUjyq4FroneXwO8Orb9OjPbZWb3ApujehS9DpYkYDEHNtKMTbDkGmY2I+ki4HPAfODjZnaHpAui/Vea2bck3UAvipwFrjKzb4ayKStddpRCOjTxupcuqWbIRei1eZxm0GY96TKuJ9VQVYKNSSC0lpS5FlKX8OAlLFM7ww0J3F2+a7pM0q2xz+vMbF3sc9I8zFMG6hg2VzOt7FFm9iCAmT0o6chYXRsH6zKzr0h6K/AN4DHgbuDCbJc4nKALKJvZBmDDwLYrBz7/MfDHeeo/fuoJ7tx9UH4DS6Ro62booKvqFuQqnaYynaU2ZzgcF0lr6HWjz6fnWFw2sH8t8B56jscM8N/N7F8rNzQitJ40CdeT4edrk55MEm3Sk9Ba0neAPQBz2k7eoMv2il07p4ft3mpmJ6UUzzIPc9gxWcpmOp+khcBbgZ8A7gH+F/B24L0j6kul+xOmWkAoJ6kpwwCrsMHnaIxHxjHUNwEnmtkLgV8FrqrUSCcXrifFKeseTspwQ9eTZOpKTNA0utDb1YZrKDPQ370kSE9XVrLOw0w6Jq3sD6PhiER/+8tEDCvzQgAz+46ZGXA98JJcVxRjIgKvqibDN4UmOEdJhLbLnaWxGDmG2swejcQG4GBGtxo5JVDk+QsRdE2qnjhj4XqSwiQHX20IWJy5xAOuPUtm2bOk8u8wyzzM9cC5UXbDU4Ed0TDCtLLrgfOi9+fRm8vZ3362pGlJx9JL2PFV4PvAaklPjY47gxLmjU9E4BWaJjlKbXBEQjpMTer5akCCjWX9NMfR6/zYvixr2SDpNZLuBP6BXiu1MwYNeAYKMcl64g05B+B6UoBJ7P3yoKt6ivZ6DQZddWBmM/SyB36OXqBzfX8eZn8uJr2hwvfQS4TxMeDX0spGZS4DzpB0N70g6rKozB30erM2ATcAF5rZXjN7APgD4GZJt9PrAXtf0esLOserjVTpKJUZJLTBQRqkb3NVE+fHoTVzvfbOY++OqWF708ZRZxoHbWafAj4l6afpzc94eS47neC4nhxcupZM1HyvdC0B1xNnDLoYdE1vn2XX0u72V9Q4tPAARs3DjHrPExNdJJWNtm8DTh9S5lLg0oTtVwJXHlgiP919giqiCa2ZbXSS4pRtf5N6vRpMljHU+zCzm4Fnl7F4oDOcvHoy6UFXnxC9X2Xc2zJ+Jxree+p64uyji0HXJDC1Y/8LYOGOefteTnn43ayJshylNjtJccp2mDz4GsnIMdSSnhOtXUG0KvwUsK1yS51K6NKcqa5cR4twPXEmgqYHlWUNZx0Mwpzy8KGGNVBGUNBVxyLEcKG8tGa4YQ6yrGUD/CK9yat7gCeAX4lNjndKps7eri7qSZlaMlFDDnPgeuL0aXpg4oyPB1/l4oFXAeoaZthFJylOWQ6TO0vpZBhD/X7g/VXb1RWqGBrmQVc6TQq+utyQA64nzuQEXU2d6xUieUvuZB17xbydHmIk0bwnp0ba4Ch12UmKMynX6Th1Mgn/Z10aQum0G19QuTt0Ncic2jn35ZSPB14V4kHXeJRxvUXveROSpzjdJ89z5noyHk3QE8fpKl0NRNpCkd6utEBrevusf7clMzLwknSRpMOqMKZNVO2QT5qT1KftzlLDM5FVjutJM3A9qQdvyCkX1xOnTroQkAzr1eoHXNPbZ5jePlOtUR0nS4/X04BbJF0vaU0/K5EzHkWc/6qdhb07plJfVVO3s+SUSqv1ZNOuA9aErYWu6EkdFL1+7/VqFK3Wk67QhQCkzeTt7UoLunp/PeAKwcjAy8x+F1gF/CnwRuBuSe+T9OzAtjmEdZLyOkN1OFB1OktNbqXWXliwY37iq4lMip40taezaXpSV0DW1uAr5HOVpiWuJ+UQIvmBM9kUeaZ2L04uv2vpPHYtncfOY6bYtXQBu5ZWnyQjaki5S9JmSZck7Jeky6P9t0dLVKSWlXS4pBsl3R39PSy27+3R8XdJemXC+dZL+mYZ15ZpjleU8vUH0WsGOAz4pKQPlGFE2xjXEc/7Ix3KSQrh3FThNHnPVzdwPZmL68nwOruoJ01uyGkjrif14r1d7acfgMVfffpBWJVImg98BDgTWA2cI2n1wGFn0mt0WQWcD1yRoewlwE1mtgq4KfpMtP9s4PnAGuCjUT19e34BeLSs68syx+s3JP078AHgS8D/ZWZvBV5Mb12ORpN1aFBTW6jLpKrW5JBOUxFnyYcI1U/b9aSthAgyqtaTEHhjTrtxPXEmmZA9qMMCsYo4GdhsZveY2W7gOmDtwDFrgWutx0ZgqaTlI8quBa6J3l8DvDq2/Toz22Vm9wKbo3qQdAjwNuC9ZV1clv7DZcAvmNn34hvNbFbSq8oyJA937j6oztNnogmt03XNpYife/6S3aXV2aRFlp2xaayetIE8etI1LYFy9SQvvk5gI2idnuxe7Gm6neJ0fNjqCuD+2OctwCkZjlkxouxRZvYggJk9KOnIWF0bE+oCeA/wJ8Djua4kgZGBl5n9Xsq+b5VliLOfMhylOh2kJEIEYHnI6yx1ffHTqnA9mUtbhp01UU/K0hJvyGkvbdWTvtPsAZiThyqDrt1LYM+S8YeTai8s3DF0UN0ySbfGPq8zs3Xx4gllbPAUQ47JUnaQxDKSXgg8x8z+H0nHjKgjM76O15iEdpS6GHTFKcs2HyJUnCKTV53qqau3q6l6UuYQxLz3Ke+IhrYE3OPgejI+be+18Pld3WT3kt7rsWfMsmfJLLOLS89uuNXMToq91g3s3wIcHfu8Engg4zFpZX8YDUck+vvQiLr+E/BiSd8F/hU4TtIXs17kMDzwCsi4P8pddpLitNVZ6hJFJq866TRlvmhRPakz5fs4tMHGruN6kp+2B19OtQSd17Vkfw9XP+CaXTzD9OJd4U6azC3AKknHSpqil/hi/cAx64FzowadU4Ed0TDCtLLrgfOi9+cBn45tP1vStKRj6WnUV83sCjN7upkdA/wU8G0zO63oxXng1RHa4iT1aZu9RWiKIz5AkcmrTgmM0+tRdSNO2/43y9ATb8gphOtJATz4cupmdyRj/WGF/V6uGoIuzGwGuAj4HPAt4Hozu0PSBZIuiA7bANxDLxHGx4BfSysblbkMOEPS3cAZ0Wei/dcDm4AbgAvNbG+o66s+OX8DyeoYN9VRapuTFKfoXI288zPyzPVq4TyvtHHURSavPli2oU5zcD3x+V5DcD1xnI4ytaMXfC3cMY89S2aZt3MBs4tn2LVzuq7gawO94Cq+7crYewMuzFo22r4NOH1ImUuBS1Ps+S5wQgbTR+KBVwOY1KCrT9HEG5PsLGlvTzCHsNXMThpWNGFb1smrToNxPSkv8UZWutCQM0JLwPXEGWDX0nk+z6tD7P//7w2G2xOFCNWHXd3GhxoGoKqhJ11wkuJ07XoaTpHJqxNJ1jUBy6YKPena0N8i19L0xD0NHbrseuI4HWFqR+918H3zWLhjHvN2eh9NmXjgVTN5f+S75CTFyXtdee7jhM/NKDJ51SlIqKx2ef4PXEsOpOnBVwNxPSmAp5V3mko/AHPKI+jdHJVeNnbcT0raK+m1ZZ6/zBbqJqX/rdJRWrBjfmXnagNNeg6KUGTyal3UrSdZKLs3YpzGAQ+6DqTK65vkhpy26UkbtMRpBz7U0hmXYP2HsfSyZ9AbYnCLpPVmtinhuPfTE+zW01ZHKS3ASts3s6T8xC9552hM8lyvPBSZvFo1k6onIQkZlORtsJk0PWnaPK8itEVPXEvKxed5dZu8vbEZ5oxOLCF7vLKklwX4deBv2L+QWaU0dLx8ImU6Sgt2zJ/zKqOeMqlqyOEkt1K3jFboSV3UPTSuq3ridBLXEscZwdTO3mt6+6wH1iUTMvAaljp2H5JWAK8BrqQDhOztKstxCOHUhKrbnSUnRmf0JOtw1ZCNAq4n2fCGnE7SOC3xdbycJtAPtuIB1/T2Gaa3z9RtWqcIGXhlSR37QeDiUQuVSTpf0q2Sbt22rfrIu+x5PXUEXSEdpJDnqsJZclpBZ/SkbFxPsuONOQ4lagnM1ZO9j+cfmurBVzvZtbS6xBOhn5F4/f3r2rXUMxqWTcgnJkvq2JOA6yR9F3gt8FFJrx6syMzWmdlJZnbSEUd4dpVxqNJBGnbuoucP7SyN20rdlQQbLSOonty5+6AQNucmVM9J0f+lJuhJUca9B96Q0zlK0xKYqyfzn1LsWfHgy6mb3Yv3P4d1Bl+jEuBE2VEvj/bfLulFo8pKOlzSjZLujv4eFtv39uj4uyS9Mrb9xZK+Ee27XFJSw81YhIxiRqaXNbNjzewYMzsG+CTwa2b2dwFtCkZWR6mq1uk6HaQkqg6+JsVZ6k9gTXp1jMbrSR3zRat6zpukJ02yJYm2DjdM05KO6UmjtcSDLyeJqp+LePBVZa8ezEmAcyawGjhH0uqBw84EVkWv84ErMpS9BLjJzFYBN0WfifafDTwfWEOvoaX/I3NFVH//XGuKXl+wu5kxvayTQpGgq4k01S6n+dStJ2UtTVFnb6nryX6a1JDjPejVUreWZCHe6+A0l6oDkqqp8TnMkgBnLXCt9dgILJW0fETZtcA10ftrgFfHtl9nZrvM7F56S16cHNW32My+EmVlvTZWJjdB+w9HpZcd2P7GceouY2hQlhbqMn8Ux/nx7pqT1KdvX5600eOmhR4nHfSWR5aw8tBwzbp3PrGc4w/ytUKLEFJPmkSI3vMu60neFPR508w77actWtJ3en2B5cmm7iC8hvMnJcA5JcMxK0aUPaq/aLuZPSjpyFhdGxPq2hO9H9xeiM6G62UunjyKpgwtabqTFCevrT453nHGo6tBV5+qer7GCXSb8pvgdAPvAXPaxry9c7Mkxl/Asn5Cmuh1/kDxLAlwhh2TpewgZdY1Ek9XUhGhW6fb4iTFKdJa7TiTTMihb23VEgizALPjlEW/5ypvEOU9YM2hqmGGdQfcu8O0IW01s5NS9mdJgDPsmKmUsj+UtDzq7VrO/jX6htW1JXqfZsfYdLbHq61MStDVJ4/tTWil7vq8jLTsP7FjFkn6qqSvS7pD0h/UYWuXKLunZFw9abOWQLP0xNmP68ncYKlo4OQ9YE5Idi/Z/6qJkQlwos/nRtkNTwV2RMMI08quB86L3p8HfDq2/WxJ05KOpZdE46tRfY9IOjXKZnhurExuPPAqSJmOUh4nqe2OEoR3lpxcJGb/GWAX8DNmdiLwQmBNJIATR5XzRbM6/5MWdPVpynWEHG5YRwbNgriexCgraPIArB663ttVdxbTjAlwNgD30EuE8THg19LKRmUuA86QdDdwRvSZaP/1wCbgBuDC2Bp+bwWuis7zHeCzRa/PhxqmULWjNA4hnItx/tnKbgkJOexwnCQbzj7WAqdF768BvghcHD8gyvLzaPRxYfQqPP7ZqZ5J15O6E23c8+gynnXI1trOXwETrychneh43XUMQ9y1dB7T29u/GH0Wuh509ZnaUWuP18gEOJFeXJi1bLR9G3D6kDKXApcmbL8VOGEc20cxsT1eTWsxHKd1uiwnqcg6LSHWeBn3urzXKyhzsv8ARyYdJGm+pNvojZW+0cz+rToTnWG4noTr+fLhhrlwPamIunrBup5aHSYn6OpTd89XV/Eer8CU/SNdhjMR4p+pX2fRFhJPuDEe8/bCou1DG4WXSbo19nmdma3rf5D0eeBpCeXemfX8UXf8CyUtBT4l6QQz+2bW8k2gjKUpyiDL0DTXk/EYR0/q7vWqmxFaAq4nrcITcZTLJASWSdTd89VFPPAqQFlj+Kvquami9aIMhymEs5R1uGHo9bwqJjVzkJm9fNg+ScOy/wyra7ukL9Jb1b1TjlIZS1NUmYwlq54UDbraoidOabietJDdi6sLvro65HBSg64+3vNVLpP9NLWMvI5SmcN3mnxOp1SGZf/Zh6SnRi3TSDoIeDlwZ1UGThpNGeLWNj0ZRzezBq1Zvwtfz2sfricTQteClKqvpynDDJ1wtPI/ZNTQoKa0UGf5cQ7ZOt2E4CevDSGcJWcsErP/SHq6pP6k1eXAFyTdTi+F641m9ve1WOsArifDcD2pnYnQk3kNHSVftTPfteDLGR/thents4mvSceHGnaUuh2kQfKMEy57vlfZ2Q27nIlsWPYfM3sAOCt6fzvwExWb1jjKSNRTRs9I6KCrSXRRT7rMJOnJ1M5m9lpUOeQQujHs0Hu7nBB4s0ROmuwoNc1J6hOypbrMVmofHuQ0jTqHGbqeOE523HneT5t7vtpsu9NsJvLJqiKVfFmOUleCrj5Nt89x2sikNeL0abp9kL0hp8oELE4YZpuxdnej8ADGcebi/xE1EaJFtQ1OCIxvZ5mt1E1JUOBMDqMc6qp6WMcJupownysrofTEcbqG98Zlw4NFJyT+dCXQlJbHcR2lNjGuY+fOkhOCJ635Elh1Y0HbtATCBF/ekOM45dCmQKYuW5scFDdpLThJh0u6UdLd0d/Dhhy3RtJdkjZLuiRLeUlvj46/S9IrY9tfLOkb0b7LJWngXK+VZJKGLrcRpz3/DRFNcJRGtVCP+jHO8oNeR9DVD4ayvMqibCdv0uZmaMaYfngm8eUUp4wMqaEpU0/K/t+uUk/aGDA2iTQtcT3pDnU5+G0KvpweUzubFXRFXALcZGargJuiz3OQNB/4CHAmsBo4R9LqtPLR/rOB59NbP/CjUT0AVwDnA6ui15rYuQ4FfgP4t6wX4P8JLaeIs1HE+SnTccpavqxeL2+ldiaJqoKuJuhJ2b3ok9aQ4ziTjAeH+2lgwNVnLXBN9P4a4NUJx5wMbDaze8xsN3BdVC6t/FrgOjPbZWb3ApuBk6MF3xeb2VfMzIBrB875HuADwJNZL6BzT1kbWqhHEdpRCjF/oyqHqaohh57Z0MlC6EQ9ZfSeZ6GMBpwyqSr4KgNvyHGcbGQJbHYtnecBUM1UEHQtk3Rr7HX+GGWPMrMHAaK/RyYcswK4P/Z5S7QtrfywMiui9wfUJekngKPHXW/Q1/EqmaKOUsigqwqHpH+OcdfY6ZfNU26QvTummL9kd/GKHKcgdSfWyKInRRpwQlKFlmRZ26sMPdnyyBJWHupjIZ1mUPWaXnGyBlX946paC8yDveRnIu/914wxvX3oEOWtZjZ0PpSkzwNPS9j1zqynT9hmOcskbpc0D/ifwBsz2rSPiQu8irZQN6EnpKlB1+D5ygiikih7IVTHaSNlNOK0RUtgfD0JqUGO03bqDL7GYTAgChGI1R10NSWxRt+O+HNRx70xs5cP2yfph5KWm9mD0TDAhxIO2wIcHfu8Enggej+s/LAyW6L3g9sPBU4Avhjl2ngasF7Sz5vZrWnX5yH+ACEzGtbhKNWZFjrvXI8yGHWvfXiQ03Sa+IzWmcAilJ54xlTHaQ/9oYh1B0tdZvfi5gSDCawHzovenwd8OuGYW4BVko6VNEUvacb6EeXXA2dLmpZ0LL0kGl+NhiM+IunUKJvhucCnzWyHmS0zs2PM7BhgIzAy6AIPvEoltKM0jtPRpHV4xrXFnaX6GSNl61JJn5R0p6RvSfpPVdvqHEjZjThN05Oq8YacYrieNJMGO9eZKCP48gBuOP0ArGHPyWXAGZLuBs6IPiPp6ZI2AJjZDHAR8DngW8D1ZnZHWvlo//XAJuAG4EIz6w+teitwFb2EG98BPlvkAvyJq4iy5nZloSkO0iBNtasITVnzLQAjU7ZGfAi4wcyOB06kJ3KdIHSiniLDlosm1Si7IaRqvCGndUy8njSVhjnVY1MkcPKgq32Y2TYzO93MVkV/H462P2BmZ8WO22Bmx5nZs83s0lHlo32XRsc/18w+G9t+q5mdEO27KMpuOGjXaVl6u8ADr9aQ1dFoopMUp8zrGOUseSroQoxM2SppMfDTwJ8CmNluM9tekX3OECahEQfaHzxOGK4nTjA8gHLaRNCnddjK0bH9r5d0e/T6sqQTi5yvyS3UaYxylOoMuhZtH5UIZnyaEkSOGh7UhEQqBQmdsvVZwI+AP5P0H5KukhRszFXVejKKUYl6ivSGpj2bVfV2lf3/V6eWZMEbckbSGT1pmpbUTdt7vWD84MuDtex4kqJyCZbVMLZy9Bn0soLcImm9mW2KHXYv8FIz+7GkM4F1wCmhbApJSEcpC2U4IMMco6TtTy5NyrCZHc84Vg6aMaa3Dl23L3TK1gXAi4BfN7N/k/QhekOI3pWxfGYmTU9CUWXQlaQbwzSmiJ5k1ZLQmrN9x8EsXfJYuBMEZoSWQEf0xLWku+xaOi9T1kMPurLhPloYQqaT37dyNICk/srR+8TNzL4cO34jc1M2lk7IFuq8lNHblddJKtICPVg2j+OUxREadcyo1PK+ptdwSkrZusXM/i36/EmGz90oSuP0pImUMcywbj0JpSVZjgu5VEXX1/JqkZ64liTQlvTyo8gafDWFJvY2DmrkniXj3895e2eZeviJkizqFiHD/rSVo5N4M0MyhUg6vz+8Yfu2yVm/KVTQtWi7lT7sJ299IQNLpxAjU7aa2Q+A+yU9N9p0OjHnpWQ6pSd5h7EW6T1vi57kra8KnfDhhrlpkp6UpiUwV0/2Pt7eHk9oZhBQNnl6uxqY2S8YZQRdTjohA6/MK0dLehk9cbs4ab+ZrTOzk8zspKVHtCv7VNoPddHW6bxOUijqcpg8I1kQRqZsjfh14C8l3Q68EHhfIHsq1ZPQ80XTyJuavGo9CdGAU7T+MoJL15MgNElPStMSmKsn85/iywp0jXjANQnB1+DSIQt3zGPhDh+aWSYhhxqmrRy9D0kvoJcf/0wz2xbQnkKktVCHWMNllHOQx0mqiv65is4DixNqfkbb52WEIvpfPD1h+wNAPGXrbcDQeR8l0ik9qZpJ0hOfP9o8GqYnriUdZ9hww3F7u5ICra4MyRxF/DfB9bRcQoaxaStHAyDpGcDfAm8ws28XOVmdLdRNJnSrdFnnDtnr5cODOkGletI20p7/MoOuuvUkK2UHmk6ncC1JYRJ6dYoyaffI9bJcggVew1aOlnSBpAuiw34POAL4qKTbJGVafKwLVOEo1eUgDVJW8OX//JOL60mYBoRxtKQJelJmY07a/rwNOSFGPzjl4loymZTR2zXOficMkg6XdKOku6O/hw05LnHJiLTykt4eHX+XpFfGtr9Y0jeifZdLUrT9GZK+EC1/cbuks8hAyKGGmNkGYMPAtitj798CvCWkDXVSl6PUBAdpkEXbLdNQIR8m5AyjSXoSKkNq2Y57yGUm6iSrnjhOEk3SkiZS93C6rEFNmo1FshtmPX/d96kqGnaNlwA3mdllUUB1CQNzMEcsGZFYXtJqer3fzweeDnxe0nFmthe4AjifXobTDcAaegl3fpdew80VUfkNwDGjLsBnzBUkj6OUt7erjh6f6YdnSqurDAcubyu143SVvM991Y04ZWoJZLPNe9EdJzz9rH9Fe4HGrSNEr9O4dXa152tq5/5Xw1gLXBO9vwZ4dcIx+5aMMLPdQH/JiLTya4HrzGyXmd0LbAZOjpa/WGxmXzEzA66NlTGg/wQsIWGuaBJBe7yaRBPX8ApBEUdpmGOUtH3X4fkenSwt1SF6vfKu59X0tXe0dy/zH36kbjM6Rej5onlSyefpPS8aVBQNupJ0o0wtgbB6EnJNrybiWuLEydKbMyz5BIznsBcJXrLYmXWYYZodu5cM19Qu9XwlXUeAddGWDQzfXWdm6zKWPcrMHgSI1gU8MuGYpCUj+gugDyu/gl6PVrzMCmBP9H5wO8C7gX+U9OvAwcDQtQzjTEzgVYQmOEohWqeLtEDHy47rOBUdJlR2YOaZDZ22Eqq3K0/QlVdPBstVrSd58IXZnUkn6xyotICkLb1FVU9/SAvyQjDsOyoUcM3sZd62oV/+VjMbmr1U0ueBpyXsemfGs2deMiJDmbS6zgGuNrM/kfSfgD+XdIKZpd64TgRebcpoGGo43DiOUtlDfvr1jeMwjXKWvJXacfJTpBGnygactPqq0hOfV+o4yQzryRl3OGDROvKeo5S6l8x9X1VA1D9vGefLe2/6PYUBerxSMbOhPUeSfihpedRbtRx4KOGwtCUjhpUfVmZL9D6prjfTm++FmX1F0iJg2RCb9uFzvBpCVY5S2U7SYN3j1D/K7qbNd3OckLQxI15oPambPA1lVXyPxx/0YPBzOE4SeQKmwblbVfV0jZPJMHNCjRp6v4qcs4yAdNyMkIFZD5wXvT8P+HTCMWlLRgwrvx44W9K0pGOBVcBXo2GJj0g6NcpmeG6szH1E6xNKeh6wCPjRqAto1N1sG1X8wJYVdI0bFBWhzOCrTHw9L6eNDHtu8wQFbdOTcc7jDTmOM5cygoSye6baMrwQxrt/ZV3XsHMWDcA6xGXAGZLuppe18DIASU+XtAGGLxmRVj7afz2wCbgBuDDKaAjwVnqLqW8GvkMvoyHAbwH/TdLXgU8Ab4wScKTSiaGGTWNcRynvj/44TlLV5BkulESeYUBNHG7YthZqSYcDf0UvNep3gV82sx8nHPebwH+jNw76Y2b2weqsLJ82DVseRkg9qasXKqueND3NfNOT9YRiUvWkTvq/m2UOj2tK0JQ0DG/YcMMsvTWJSUJS/I6q52DlPXdXEn7EMbNtRL1MA9sfAM6KfT5gyYi08tG+S4FLE7bfCpyQsH0T8J/HMB/oQI9XFxylYaT9c2V1kuoerpPFhry9Xt5KHZT+WhergJuiz3OQdAI9J+lk4ETgVZJWVWqlk5ky9KRustiQdi15NGNYg5n3oI+F60nLqSvo6vf0xF/xfVWwZ8kse5ZUO88pjap7v5oScHeF1gdek0hbnKQ4RYIvD7BqIctaGc8DNprZ41HX/j8Dr6nGvPoYtTRFFZTZe942PQkVfLnOBGUi9GReQwZaDDrlRZ30Kh3vYUFWprIBhvvFA674+yYM+wtpQ1lrszkH4kMNK2JcR6mIE1AoTfzWJ1P371q2KH/dD8+kDhVq+jChJJ51yNa6TUgj9FoZ3wQulXQE8AS9bv5bE46bKNLWBBy2NMWw+aJl9aoM05PQQVcoPRmlJdBOPWk4ricZ6A/vcod1fPIEEkWH/Q1+T2PN6yp5yGGZgVSeYYbDntkmBJldwgOvkgk9/GSUozSOkzTKKcpapkgwlpVhc72GbR93nldr1/LaM8PsD4ZmLg26VoaZfUvS+4EbgUeBrwPN6RoZk7YPW667EadqPckSfA1jXD2ZCNK1BFxPxiLu+FbdYzRse5N7dZv4f5c0vHDPklkW7ujWYLFRC0c75dLqwCuro1RkaNC4LdTjMK6jVHfQlVZXWc5S6FZqX/h0PyWslYGZ/Snwp1GZ9zF3hXcnAGWtBeh6kp0mJuxpGq4nw/FesPIZFgAVWdNrWJAxu7inhfN2FnOZ++thNSw9exhm9jL7o211W9FIJuDbnwyyOknTW58s1UnKU2/eoUs+N6NSsqyVQX/IkKRnAL9AL6Wq0xDy/m9Msp6MgyfYyIzrCfVnmQs6J6hAwoes5fpJLgZ7otLK5138Ny2ZRtPmeg0y7nOWdrz7V+XjgVcFjNNCnae3axwnKTRZHaY0m6tc28sZysi1MiL+RtIm4DP01r04IEV0G+jqMMNhtElPMh1Xop403dFo29IUEROlJ2nUHXyFoEimwSzHD8sqWEWmwX5v1+D7cRknAGxaFsWma2LbaO1QwzIdpbTJ8KGo8kGuwkFKOueo4UJpw4SGDREaZw6GDw/KzxhrZfyXKu2aJIr2puTRmCxBV9V60j9fFXNJy6K1c0YD4Xoyl6mdYYYdZvltrGKuVxnnGDfwSDrnqGBn2HfQP3c/0JpevAuAXTun5xwTeq5XlfPJQj2TzoF4j1eJhHKUirRO1xF0xc896vxNSlMdipa2UDsNpIz5XUV6lOvWk9T9OXq9xnEOy5pb5zhdIi2ZR56yWXp7ZhfP7AuKyuoZytqgm6fXazAATAoI++cfvJ4qe77a0Bsr6XBJN0q6O/p72JDj1ki6S9JmSZdkKS/p7dHxd0l6ZWz7pZLul/TowDneJmmTpNsl3STpmVmuoZWBV5uGBYX8sU5zNIrOvZj/8CNzXkXIa8c4zpJ3hTt5qVtPiibqGefZz9uI0xQ9GWXHJDTkON2gTie3rHlJo+pJm/eVx4Z4wNX/nIVxh/nF6+73dsXfjxN85Z1jlmRTFgafqzLO3zCyLMY+H/gIcCawGjhH0uq08tH+s4HnA2uAj0b1QG/o88kJtvwHcJKZvQD4JPCBLBfQysCr7YwTOAxzlEY5SeMyyjEq6jg1yVnyCfFO1xm3IaJMPRnUiqboiTfkOE2jzOBrWO9RExgneUYSgwHXsHJlJ7roB1rLDn2MZYc+Nmdb3vNOb8/n7xT5LscJvlrQ65VlMfaTgc1mdo+Z7Qaui8qllV8LXGdmu8zsXmBzVA9mtrG/DmEcM/uCmT0efdwIrMxyAR54tZCyApUijk8ex6lMZykrPjzISeOJ2YV1m1AZIRtxivZm5SnfpMacMmj4YuxOIPI4ulnK9B31YQ570SClSPlxgsRhAVee3qdRDPZ2DdIPvrKe98AhhtlsHVb3uMFX/Pwd6vmasxg7kLQY+wrg/tjnLdG2tPJpZbLwZuCzWQ5sXXKNJjhKZazhlYU8QUcWR6no0MFhde49/NCRx6Ul3RhnQdSkJBuTuPjpztltn/vHx64dlh3GPbmWktQrm9SIULS3pqygq0z69WXRk3EJvU5gaELOFx2hJeB6UitN74noBwXDkkGMm3BjVMA1LtPbZ4eun5XkN8R7u1Ye0jN8y6P5HYzBoCvJnnhgNbt4pvC6YXkpI9HGCD1ZJOnW2Od1Zrau/6HoYuxAksiPcqjzlOkVlP4rcBLw0izHty7wajt1O0ohgq7Bust2mJrqLGVpoQ6dWMPM1gQ9gdMJQizREFJL+vWP0pKqG3KSMqWOsyj7ykObO4bRtaQ+0hZYLiPgKpodbxxHPM+5BntysgRdyw59jK3szzRYVgbATD1Zi3eNPG8ZPUzjBl/xZyXp/GnBZ1JdRYKvInpSwmLsW4CjY59XAg9E74eVTyszFEkvpxcQvtTMMrUK+FDDksjaQp2VcR2lUUFXGUkysjLqPF0bIuQ4baRII06VWlJET5LwdQKdphJ3nKd2jljYNmVf1XO7yjxf1qArS5mi9Hu7jj14K8cevJWVh+w44NxZOLC3a7i9s4tn5lzr4LUVvdcdGHKYZTH2W4BVko6VNEUvacb6EeXXA2dLmpZ0LLAK+GqaIZJ+Avj/gZ83s6QAMBEPvFrEMEepKU7SOOcsw1nyCfCOM5ek/4kQjThVk1dPvCHHaRujAq685HXYk2wZNaS/zEBsevGuxCQX/c/jDD3MGnQM1nncoh9w3KIfcOzBc0e5DA0Sh5xn6uEnmHr4iVw25CVvMg9o7PDWkYuxm9kMcBHwOeBbwPVmdkda+Wj/9cAm4AZ6C7jvjer+gKQtwFMkbZH07qiuPwYOAf5a0m2S+sFdKkGHGkpaA3wImA9cZWaXDexXtP8s4HHgjWb2tZA2NY2sjlKeoKuIgzT7g7nB+7ynJc1fTGfU0MNhw4TGGSI0yCTO85oUXE/mUqThoUo9GdQSqFZPkkgavtx07fD1AMvDtaQ8BhNS9IfGZR36NzivKc6wXq5x5lxNb59h19LR/sRgsBjv7YrTP3d8mOOo8+elP6Rx3CGHowLMKoccls0Yi7FvADZkLR/tuxS4NGH77wC/k7B96JDINIIFXrE8+mfQGzt5i6T1ZrYpdtiZ9LrzVgGnAFdEfztJlT004zhJSY5RlmOyOk9pczXGcZbykjQvowrcUSqPLujJlkfye/V5hy2P09tVVtCVR0/GCcSyJvLp4w05TpwuaEkaaQkaypoHFZrB3p6koCv+/vsJAdD09tmxg57+ML940HXcoh9w/PTcqT5pAd/cTIL7z5/W0xXXmGE9XfHvMuv32D9/1uDTqYaQ/4FpefT7rAWutR4bgaXRZLdKaVIa3zJ6u7I6SbM/eCiTkzSqfJY6xm0tT7rmOoYbNnky/ITRGj2pi6z/C+MOv8vyvzuOFpRRfphN4ww59LleE8tEaEm/9yht/tOoRoVRQ82S0q/H3w/2Ig2eL6m3a1jQtfKQHfsCrf6cqz7Ti3cxu3hm6BDHeACUZ47Tcxfu5rkL9yfQ6c/1yjocsB90zdu2k3nbkm/qniWz++7BsHXDkr7LrA1DSVkVs9LQIYetJWTglSUnftG8+Y0lSwt1oaFCBYKuogHXsDpHMa6z5DgxJlpP8lBGb1dWPSmToo05RfQkiyaHWBuwSY1/E0BntKQOhziLoz9O8JVGPOjqEw+4BocBjlv/MIb1dh0//QDHLfrBnGOHz/PqbU/q6Zp6+Ammt8/knnMGB97X/rPQrzPp/EWGPTrlEbLvMUtO/Ex58yWdD5wffdx1wfE3f7OgbWWzjOatcVK9Td9J3duzJ/2Yqhl5j2oY1P/c6k/ZClxP6qMee1xPysD15EBK0xI4UE++9rG3NUlPmqYlMIZN3w5sSIw5NqWf917gS8XO9t303d9OsKkBuJaURMjAK0tO/Ex586OF1dYBSLrVzE4q19RiuE2jaZo90Fyb6rahobie1ETT7AG3KSuuJ4mUpiXQbD1pmj3gNmWlaTa5lpRHyKGGaXn0+6wHzlWPU4EdZuYZCRzHGcT1xHGcMnAtcRynNoL1eJnZjKR+Hv35wMfN7A5JF0T7r6SX6vEsYDO9lK1vCmWP4zjtxfXEcZwycC1xHKdOguaXTMqjH4la/70BF45Z7boSTCsbt2k0TbMH3KZW4XpSG02zB9ymrDTRptoJpCXQvPvdNHvAbcpK02xqmj2tRT19cRzHcRzHcRzHcULR/JX0HMdxHMdxHMdxWk5jAy9JayTdJWmzpEsS9kvS5dH+2yW9qAE2vT6y5XZJX5Z0Yp32xI77SUl7Jb02pD1ZbZJ0mqTbJN0h6Z/rtknSEkmfkfT1yKag4/klfVzSQ5IS0w7X8Wx3nabpSdO0JItNseNcT1xPJpamaUlGm1xPMtpUpZ40TUuic7qehMbMGveiN+H1O8CzgCng68DqgWPOAj5Lb72NU4F/a4BNLwEOi96fGdKmLPbEjvsneuPZX9uAe7QU2AQ8I/p8ZANsegfw/uj9U4GHgamANv008CLgm0P2V/psd/3VND1pmpZktSl2nOuJ68lEvpqmJWPY5HrSMD1popZE53E9Cfxqao/XycBmM7vHzHYD1wFrB45ZC1xrPTYCSyUtr9MmM/uymf04+riR3toftdkT8evA3wAPBbRlHJteB/ytmd0HYGah7cpikwGHShJwCD1xC7bEu5ndHJ1jGFU/212naXrSNC3JZFOE64nrySTTNC3JZJPrSWabqtSTxmkJuJ5UQVMDrxXA/bHPW6Jt4x5TtU1x3kyvVaA2eyStAF4DXEk1ZLlHxwGHSfqipH+XdG4DbPow8Dx6C2R+A/hNM5sNbFcaVT/bXadpetI0LQHXkzJtcj3pLk3Tkjzncz0ZYhPV6kkbtQRcTwoTNJ18AZSwbTD9YpZjyiTz+SS9jJ64/VTN9nwQuNjM9vYaTIKTxaYFwIuB04GDgK9I2mhm367RplcCtwE/AzwbuFHSv5jZzkA2jaLqZ7vrNE1PmqYl4HpSpk2uJ92laVoy1vlcTw6gTj1po5aA60lhmhp4bQGOjn1eSS/iH/eYqm1C0guAq4AzzWxbzfacBFwXidoy4CxJM2b2dzXatAXYamaPAY9Juhk4EQjlKGWx6U3AZWZmwGZJ9wLHA18NZNMoqn62u07T9KRpWpLVJtcT15NJp2lakvl8rieN05M2agm4nhQn5ASyvC96AeE9wLHsn3T4/IFjfpa5E/y+2gCbnkFvpfuXNOEeDRx/NeEnr2a5R88DboqOfQrwTeCEmm26Anh39P4o4PvAssD36hiGT16t9Nnu+qtpetI0Lclq08DxrieuJxP3apqWjGGT60nD9KSpWhKdy/Uk4KuRPV5mNiPpIuBz9DK/fNzM7pB0QbT/SnpZcM6iJyaP02sZqNum3wOOAD4ateLMmNlJNdpTKVlsMrNvSboBuB2YBa4ys8S0pVXZBLwHuFrSN+iJycVmtjWUTZI+AZwGLJO0Bfh9YGHMnkqf7a7TND1pmpaMYVOluJ5kw/WkOpqmJWPY5HrSMD1popaA60kVyMyHZjqO4ziO4ziO44SkqVkNHcdxHMdxHMdxOoMHXo7jOI7jOI7jOIHxwMtxHMdxHMdxHCcwHng5juM4juM4juMExgMvx3Ecx3Ecx3GcwHjg5TiO4ziO4ziOExgPvBzHcRzHcRzHcQLjgZdzAJJ+UtLtkhZJOljSHZJOqNsux3Hah+uJ4zhl4XritB1fQNlJRNJ7gUXAQcAWM/ujmk1yHKeluJ44jlMWridOm/HAy0lE0hRwC/Ak8BIz21uzSY7jtBTXE8dxysL1xGkzPtTQGcbhwCHAofRalhzHcfLieuI4Tlm4njitxXu8nEQkrQeuA44FlpvZRTWb5DhOS3E9cRynLFxPnDazoG4DnOYh6Vxgxsz+t6T5wJcl/YyZ/VPdtjmO0y5cTxzHKQvXE6fteI+X4ziO4ziO4zhOYHyOl+M4juM4juM4TmA88HIcx3Ecx3EcxwmMB16O4ziO4ziO4ziB8cDLcRzHcRzHcRwnMB54OY7jOI7jOI7jBMYDL8dxHMdxHMdxnMB44OU4juM4juM4jhMYD7wcx3Ecx3Ecx3EC838Ak08N2xn2JhYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1008x216 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "z_mesh = U(x_mesh,y_mesh)\n",
    "#z_mesh[~governing_equation_mask] = np.nan\n",
    "\n",
    "fig, axs = plt.subplots(1,3,constrained_layout=False, figsize=(14, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "#temp[~governing_equation_mask]=np.nan\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tf.Variable 'conv2d_7/kernel:0' shape=(1, 1, 2, 1) dtype=float32, numpy=\n",
       " array([[[[0.21499602],\n",
       "          [1.0753525 ]]]], dtype=float32)>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.99776625"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.19955325*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth_data':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0),\n",
    "                     'k1':pde_model_train.layers[-6].weights[0][0,0,0,0].numpy(),\n",
    "                     'k2':pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.21499602"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0753525"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0017323"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03464698791503906"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()-5)/5*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
